The present invention operates in an object oriented environment. In client-server relations in this environment, defined protocols allow data to be marshaled between the client and the server. This data pertains to “objects” as that term is applied in the software arts. Marshaling of data for transmission to a client refers to manipulation of that data from an object as it exists in memory into a form suitable for transmission under a defined protocol for managing and transmitting object oriented information for software objects. Marshaling of data is also describable as the conversion between representations of data, formats for calling functions, and formats for returning values. However, it is noted that from time to time updates made to the objects being marshaled, or to protocol support, in the client or the server, can cause problems with migration, especially if the updates introduce issues with respect to data marshaling. For example, in one version of an object there may be two expected fields which are combined into a single field in another version of the object. In another example, there may be differences in the order in which numbers in a two-dimensional array are presented, such as by row in one form or by column in another form. Upon an attempt at demarshaling such data, an error is likely to be generated requiring additional communications to resolve it. The present invention seeks to reduce the need for such communication.
One of the more well known marshaling protocols for use in objected oriented technology is the CORBA GIOP protocol. GIOP is an acronym that stands for “General Inter-ORB Protocol.” CORBA is an acronym that stands for “Common Object Request Broker Architecture.” A central component of this protocol model is the Object Request Broker (ORB) which enables objects to “make and receive responses in a distributed environment.” The CORBA protocol is promulgated and controlled by the Object Management Group, Inc. In particular, the CORBA protocol defines a call back mechanism (SendingRuntimeContext) which, when received data cannot be properly demarshaled, allows one side of an established client-server connection to request information about how the data was marshaled. In Java implementations of the ORB, this translates to a Full Value Description (FVD) callback. FVD is a CORBA-specified structure containing attributes that describe a CORBA object: it's operations, supported interfaces, and other attributes affecting its behavior in the CORBA environment. When a FVD callback is made, the ORB caches the result, namely meta-data about the fields used by the remote class to marshal data (meta-data here refers to descriptive information about the information object being marshaled-what fields are or are not present, for example so that the next time similar data is received, a callback is not repeated.
If two-way connections (with requests flowing in both directions on the same connection) are supported, this callback mechanism is sufficient to ensure that both sides can demarshal data from different, but compatible, objects on either end of the communications path. However, when two-way connections are not available or are not supported, separate connections for these callbacks must be established. This can be problematic, especially as callbacks from a server to an arbitrary client may have to pass through a firewall. For the purpose of understanding the advantages of the present invention, a firewall is a mechanism (hardware or software) that prohibits the passage of data that does not meet certain criteria. These criteria cannot always be anticipated in advance. However, there is frequently a firewall between two ORBs. This can prevent the callback from succeeding due to an outright block by the firewall or due to the presentation of insufficient credentials (for example, a client doesn't usually define credentials for inbound connections).
There are two principal ways to avoid making server-to-client callbacks. The first is to insure that all deployed clients are running the same version of code as the server. This may not be feasible depending on the mix of software deployed at the client end of the system. The second is to insure that the server can support all possible versions of the client. This could (and arguably should) be achieved via marshaling and/or demarshaling code within the class itself.